{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1e123cbb",
   "metadata": {},
   "source": [
    "# 实验二：决策树\n",
    "\n",
    "### 罗玉轩 20221202433 \n",
    "\n",
    "## 一、实验目的\n",
    "1. 了解决策树模型的相关知识。\n",
    "2. 学习如何处理分类数据并将其转换为数值特征。\n",
    "3. 掌握决策树回归器在分类问题中的应用。\n",
    "\n",
    "## 二、实验环境\n",
    "- **系统**：Windows 11\n",
    "- **软件**：PyCharm\n",
    "- **需要安装的库**：\n",
    "  - Python 3.9\n",
    "  - NumPy\n",
    "  - Pandas\n",
    "  - Matplotlib\n",
    "  - scikit-learn (版本 >= 0.18)\n",
    "\n",
    "## 三、实验内容\n",
    "本实验使用的数据集为西瓜数据集，包含17个样本数据，每个样本有7列，分别是：\n",
    "- 色泽（青绿、乌黑、浅白）\n",
    "- 根蒂（蜷缩、稍蜷、硬挺）\n",
    "- 敲声（浊响、沉闷、清脆）\n",
    "- 纹理（清晰、稍糊、模糊）\n",
    "- 脐部（凹陷、稍凹、平坦）\n",
    "- 触感（硬滑、软粘）\n",
    "- 好坏（好瓜、坏瓜）\n",
    "\n",
    "前6列作为样本特征，最后一列\"好坏\"作为样本输出标签，我们试图通过决策树回归模型来预测西瓜的好坏。\n",
    "\n",
    "由于西瓜数据集的特征都是文本类型，需要先将其转换为数值特征，然后才能应用决策树算法。样本数据按3:1随机划分成训练集和测试集，通过使用scikit-learn库中封装好的决策树回归算法进行训练和预测。\n",
    "## 四、实验步骤 \n",
    "\n",
    "1. 环境搭建 \n",
    "Win11系统中安装python3.9，然后使用pip安装所需要的各个库。 \n",
    "\n",
    "命令如下：\n",
    "\n",
    "pip install 库名 \n",
    "\n",
    "2. 数据预处理 \n",
    "\n",
    "编写prepareDataSet()函数，对西瓜数据集进行处理，将文本特征转换为数值特征，并将标签\"好瓜\"编码为1，\"坏瓜\"编码为0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8d72116",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepareDataSet():\n",
    "    \"\"\"准备数据集，将文本特征转换为数值特征\"\"\"\n",
    "    # 创建DataFrame\n",
    "    df = pd.DataFrame(dataSet, columns=feature_names)\n",
    "    \n",
    "    # 分离特征和标签\n",
    "    X = df.iloc[:, :-1]  # 所有行，除最后一列外的所有列作为特征\n",
    "    y = df.iloc[:, -1]   # 所有行，最后一列作为标签\n",
    "    \n",
    "    # 对标签进行编码：好瓜->1，坏瓜->0\n",
    "    label_encoder = LabelEncoder()\n",
    "    y_encoded = label_encoder.fit_transform(y)\n",
    "    \n",
    "    # 对特征进行编码\n",
    "    X_encoded = X.copy()\n",
    "    for column in X.columns:\n",
    "        X_encoded[column] = label_encoder.fit_transform(X[column])\n",
    "    \n",
    "    return X_encoded, y_encoded"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55ac6edc",
   "metadata": {},
   "source": [
    "3. 划分训练集和测试集\n",
    "\n",
    "编写getTrainSetAndTestSet()函数，按3:1的比例划分训练集和测试集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5d9ff070",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getTrainSetAndTestSet(X, y):\n",
    "    \"\"\"划分训练集和测试集\"\"\"\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=1)\n",
    "    print(\"训练集特征维度:\", X_train.shape)\n",
    "    print(\"训练集标签维度:\", y_train.shape)\n",
    "    print(\"测试集特征维度:\", X_test.shape)\n",
    "    print(\"测试集标签维度:\", y_test.shape)\n",
    "    return X_train, X_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "468a6c20",
   "metadata": {},
   "source": [
    "4. 训练决策树回归模型\n",
    "\n",
    "编写TrainDecisionTreeRegressor()函数，创建一个决策树回归模型，并使用训练集数据进行训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1e22edb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def TrainDecisionTreeRegressor(X_train, y_train):\n",
    "    \"\"\"训练决策树回归模型\"\"\"\n",
    "    # 创建决策树回归模型\n",
    "    tree_reg = DecisionTreeRegressor(criterion='squared_error', max_depth=3, random_state=1)\n",
    "    # 训练模型\n",
    "    tree_reg.fit(X_train, y_train)\n",
    "    print(\"决策树特征重要性:\", tree_reg.feature_importances_)\n",
    "    return tree_reg"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a629fb1",
   "metadata": {},
   "source": [
    "5. 评估模型性能\n",
    "\n",
    "编写EvaluationModel()函数，使用测试集评估模型性能，计算均方误差、均方根误差和准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7646239b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def EvaluationModel(tree_reg, X_test, y_test):\n",
    "    \"\"\"评估模型性能\"\"\"\n",
    "    y_pred = tree_reg.predict(X_test)\n",
    "    mse = np.mean((y_pred - y_test) ** 2)\n",
    "    print(\"均方误差MSE:\", mse)\n",
    "    rmse = np.sqrt(mse)\n",
    "    print(\"均方根误差RMSE:\", rmse)\n",
    "    \n",
    "    # 计算准确率（将预测值四舍五入后与实际值比较）\n",
    "    y_pred_rounded = np.round(y_pred)\n",
    "    accuracy = np.mean(y_pred_rounded == y_test)\n",
    "    print(\"准确率:\", accuracy)\n",
    "    \n",
    "    return y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42e1fd4a",
   "metadata": {},
   "source": [
    "6. 可视化结果\n",
    "\n",
    "编写Visualization()函数，绘制预测值和实际值之间的关系图。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b6e982f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Visualization(y_test, y_pred):\n",
    "    \"\"\"可视化结果\"\"\"\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.scatter(y_test, y_pred)\n",
    "    ax.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], 'k--', lw=5)\n",
    "    ax.set_xlabel(\"Measured\")\n",
    "    ax.set_ylabel(\"Predicted\")\n",
    "    \n",
    "    plt.show()\n",
    "    plt.close(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc68a597",
   "metadata": {},
   "source": [
    "7. 完整代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "120e4c60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集特征维度: (12, 6)\n",
      "训练集标签维度: (12,)\n",
      "测试集特征维度: (5, 6)\n",
      "测试集标签维度: (5,)\n",
      "决策树特征重要性: [0.09615385 0.         0.         0.34615385 0.48076923 0.07692308]\n",
      "均方误差MSE: 0.4\n",
      "均方根误差RMSE: 0.6324555320336759\n",
      "准确率: 0.6\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMp0lEQVR4nO3dd1hTB/8F8JMwVYYDBVQqamut1RKGIDirVK1W69sBat1bcaJVcdG6UOuss+JCBQGtWutAK0pdqJVhtQ7cWC1YFyAIgeT+/vDXvOUFJGCSS5LzeZ48T7n5XjjctuZ4p0QQBAFEREREBkIqdgAiIiIiTWK5ISIiIoPCckNEREQGheWGiIiIDArLDRERERkUlhsiIiIyKCw3REREZFBMxQ6ga0qlEg8fPoS1tTUkEonYcYiIiEgNgiAgKysLtWvXhlT6+n0zRlduHj58CCcnJ7FjEBERUTncv38fdevWfe2M0ZUba2trAK82jo2NjchpiIiISB2ZmZlwcnJSfY6/jtGVm38ORdnY2LDcEBER6Rl1TinhCcVERERkUFhuiIiIyKCw3BAREZFBYbkhIiIig8JyQ0RERAaF5YaIiIgMCssNERERGRSWGyIiIjIoLDdERERkUIzuDsVERESkHfICJbbF38W9pzmoV70y+no7w9xU9/tRRN1zc+LECXTr1g21a9eGRCLB3r17S10nLi4Obm5usLCwwNtvv40tW7ZoPScRERG9XsjBK2g88xDmHLiKrfH3MOfAVTSeeQghB6/oPIuo5SY7OxsuLi5YvXq1WvN37txB165d8eGHHyI5ORnjx4/HkCFDcPjwYS0nJSIiopIEbf8V86aMRcHLF4WWKwXghxN3dF5wJIIgCDr9iSWQSCTYs2cPevToUeLMlClTcODAAVy+fFm1rGfPnnj+/DliYmLU+jmZmZmwtbVFRkYGH5xJRET0hg7GHEa3z3tCmfMclRv5wK5HUJGHW0olwLU5H7/RIaqyfH7r1QnF8fHx8PX1LbSsU6dOiI+PL3GdvLw8ZGZmFnoRERHRmykoKMCMGTPwSZePocx5DgDISTmDF0kHiswqBWBb/F2dZdOrcpOWlgZ7e/tCy+zt7ZGZmYmXL18Wu05ISAhsbW1VLycnJ11EJSIiMlgPHjxA+/btMW/ePPzvAaCnxzYgL+1mkXXuPc3RVTz9KjflERQUhIyMDNXr/v37YkciIiLSWzExMZDJZDh58mTxA4oCPP5pIZR5hctMveqVdZDuFb0qNw4ODkhPTy+0LD09HTY2NqhUqVKx61hYWMDGxqbQi4iIiMomPz8fU6dOxccff4zHjx+/drbg+V94fnKb6mupBOjr7azlhP+lV+XG29sbsbGxhZb98ssv8Pb2FikRERGRcThw4AAWLlyo1mylRt6wbfWV6uuhrevr9H43opabFy9eIDk5GcnJyQBeXeqdnJyM1NRUAK8OKfXr1081P2LECNy+fRuTJ0/GtWvXsGbNGkRHR2PChAlixCciIjIan376Kb766qvXD5mYoprvcNTsMQ0mllaQSoDhbeojqEsT3YT8f6JeCh4XF4cPP/ywyPL+/ftjy5YtGDBgAO7evYu4uLhC60yYMAFXrlxB3bp1MXPmTAwYMEDtn8lLwYmIiMonKysLHh4eSElJKfJew4YNsT18B/6Q19DKHYrL8vldYe5zoyssN0REROV38eJFeHl5IS8vT7XMz88P69evh62trdZ+rsHe54aIiIjE5eLighUrVgB4ddHOunXrEBkZqdViU1Z8cCYRERGVybBhw3Dnzh306tULLi4uYscpgoeliIiIjJxCoYCJiYnYMV6Lh6WIiIhILdHR0WjatCkePXokdhSNYbkhIiIyQi9fvsSIESPg7++Pa9euoV+/flAqlWLH0giWGyIiIiNz/fp1tGjRAj/88INq2eHDh7Fo0SIRU2kOyw0REZERCQ8Ph7u7O37//fci782YMQOnT58WIZVmsdwQEREZgZycHAwZMgR9+vRBdnZ2sTMKhQI9e/bEkydPdJxOs1huiIiIDNyVK1fg6emJjRs3ljr7559/Ijo6WgeptIflhoiIyIBt2bIFzZs3xx9//FHqrJWVFSIiIjBy5EgdJNMe3sSPiIjIAL148QIBAQHYunWrWvMymQzR0dF45513tJxM+7jnhoiIyMBcunQJzZs3V7vYjBo1CvHx8QZRbACWGyIiIoMhCAJCQ0Ph6emJa9eulTpvY2ODnTt3YvXq1bC0tNRBQt3gYSkiIiIDkJWVheHDh2PHjh1qzXt4eCAqKgoNGjTQcjLd454bIiIiPZecnAx3d3e1i824ceNw6tQpgyw2AMsNERGR3hIEAWvXrkWLFi1w48aNUuerVq2KPXv2YPny5bCwsNBBQnHwsBQREZEeysjIwNChQ7Fz50615r28vBAVFYV69eppOZn4uOeGiIhIz1y4cAFubm5qF5tJkybh5MmTRlFsAO65ISIi0itKpRKDBw/G7du3S52tXr06tm7diq5du+ogWcXBPTdERER6RCqVYtu2baVeut2yZUskJycbXbEBWG6IiIj0zgcffIAVK1aU+H5QUBDi4uLg5OSkw1QVB8sNERGRHho6dCj8/f0LLatZsyZiYmIwf/58mJoa75knLDdERER6SCKRYP369Xj77bcBAO3atUNycjI6deokcjLxGW+tIyIi0nM2NjaIjo7GTz/9hJkzZ8LExETsSBUCyw0REVEFoVQqAbw6aVhdrq6ucHV11VYkvcTDUkRERBXAo0eP8PHHH2PhwoViR9F7LDdEREQii4uLg0wmw5EjRzBz5kycOnVK7Eh6jeWGiIhIJAqFArNnz0aHDh3w119/qZb17NkTjx8/Fjmd/mK5ISIiEkFaWho6duyI4OBg1bk2/3jw4AEGDBhQZDmph+WGiIhIx44ePQqZTIZjx46VOHPgwAEsXbpUh6kMB8sNERGRjhQUFGDmzJno2LEj0tPTS51fu3YtcnNzdZDMsLDcEBER6cCDBw/QoUMHzJ07F4IglDr/ySef4Pz586U+Q4qKYrkhIiLSspiYGMhkMpw4caLUWVNTUyxZsgT79u1DjRo1dJDO8PAmfkRERFqSn5+PWbNmYcGCBWrN16tXD1FRUfDy8tJyMsPGckNERKQF9+/fR8+ePXHmzBm15nv06IFNmzahWrVqWk5m+HhYioiISMP2798PmUymVrExMzPDihUrsHv3bhYbDeGeGyIiIg2Ry+UICgpS+xLuBg0aICoqCh4eHlpOZlxYboiIiDTg7t276NmzJ86dO6fW/JdffonQ0FDY2tpqOZnx4WEpIiKiN7R37164urqqVWwsLCywdu1aREVFsdhoCffcEBERlVNeXh4mT56M77//Xq35d955B9HR0ZDJZNoNZuS454aIiKicfvrpJ7WLTe/evZGQkMBiowMsN0REROX05Zdfwt/f/7UzlpaW2LBhA7Zv3w5ra2sdJTNuLDdERETlJJFIsH79erz99tvFvt+4cWP89ttvGDx4MCQSiY7TGS+WGyIiojdgY2OD6OhomJubF1rev39/XLhwAU2bNhUpmfFiuSEiInpDrq6uqnvbVK5cGVu2bMGWLVtQpUoVkZMZJ14tRUREpAGjRo3C/fv30a9fPzRp0kTsOEZNIqjz3HUDkpmZCVtbW2RkZMDGxkbsOEREVEEVFBTA1JT7ACqKsnx+87AUERHR/wgLC8P777+Px48fix2FyoHlhoiI6P9lZ2djwIABGDBgAFJSUtC/f38olUqxY1EZsdwQEREBuHTpEjw8PBAWFqZadvDgQSxZskTEVFQeLDdERGTUBEHAhg0b4OnpiWvXrhV5f9q0aYiPjxchGZUXyw0RERmtrKws9OnTB0OHDkVubm6xMwUFBejZsyeePn2q43RUXiw3RERklJKTk+Hu7o6IiIhSZ1NTU7F3717thyKNYLkhIiKjIggC1q5dixYtWuDGjRulzletWhW7d+/GoEGDdJCONIEX8BMRkdHIyMjA0KFDsXPnTrXmPT09ERUVBWdnZ+0GI43inhsiIjIKFy5cgJubm9rFZuLEiTh58iSLjR5iuSEiIoMmCAK+//57+Pj44Pbt26XOV69eHfv27cPixYuLPAyT9IPo5Wb16tVwdnaGpaUlvLy8cP78+dfOL1++HO+++y4qVaoEJycnTJgwocQz3ImIyLg9e/YMn332GcaNG4f8/PxS5318fJCcnIxu3brpIB1pi6jlJioqCoGBgQgODkZiYiJcXFzQqVMnPHr0qNj5iIgITJ06FcHBwbh69So2btyIqKgoTJs2TcfJiYioojt37hxcXV3Vvspp6tSpiIuLg5OTk3aDkdaJ+uBMLy8vNG/eHKtWrQIAKJVKODk5YcyYMZg6dWqR+dGjR+Pq1auIjY1VLZs4cSLOnTuHU6dOFfsz8vLykJeXp/o6MzMTTk5OfHAmEZGBUiqVWLZsGaZOnYqCgoJS5+3s7LBt2zZ07txZB+movPTiwZlyuRwJCQnw9fX9bxipFL6+viXeCdLHxwcJCQmqQ1e3b9/GwYMH0aVLlxJ/TkhICGxtbVUvNnIiIsP15MkTdO/eHZMmTVKr2LRp0wbJycksNgZGtHLz+PFjKBQK2NvbF1pub2+PtLS0Ytfp3bs3Zs+ejVatWsHMzAwNGzZEu3btXntYKigoCBkZGarX/fv3Nfp7EBFRxXD69GnIZDIcOHCg1FmJRIKZM2ciNjYWderU0UE60iXRTygui7i4OMyfPx9r1qxBYmIidu/ejQMHDmDOnDklrmNhYQEbG5tCLyIiMiwKhQJDhw7Fn3/+Weqsvb09jhw5gtmzZ8PUlLd7M0Si/Vu1s7ODiYkJ0tPTCy1PT0+Hg4NDsevMnDkTffv2xZAhQwAAzZo1Q3Z2NoYNG4bp06dDKtWrrkZERBpiYmKC8PBwtGjRAnK5vMS5Dh06YPv27SV+zpBhEK0NmJubw93dvdDJwUqlErGxsfD29i52nZycnCIFxsTEBMCr+xgQEZHxcnV1xbJly4p9TyqVYvbs2Th8+DCLjREQdX9cYGAg+vfvDw8PD3h6emL58uXIzs7GwIEDAQD9+vVDnTp1EBISAgDo1q0bli5dCldXV3h5eeHmzZuYOXMmunXrpio5RERkvEaOHInjx49j165dqmWOjo7YsWMH2rZtK2Iy0iVRy42/vz/+/vtvzJo1C2lpaZDJZIiJiVGdZJyamlpoT82MGTMgkUgwY8YMPHjwADVr1kS3bt0wb948sX4FIiKqQCQSCTZs2ICEhATcuXMHnTp1wtatW1GrVi2xo5EOiXqfGzGU5Tp5IiLSTxcuXMDRo0cxefJkno9pIMry+c3TxImIqEJTKBSQSCRlKikeHh7w8PDQYiqqyFhniYiownr48CE6dOiAJUuWiB2F9AjLDRERVUgxMTFwcXHBr7/+iqCgoBLvXk/0v1huiIioQikoKEBQUBA+/vhjPH78GMCrQ1M9e/bE06dPRU5H+oDlhoiIKoz79++jXbt2WLBgQZH3UlNTMXDgQN7XjErFckNERBXC/v37IZPJcPr06RJn9u3bhxUrVugwFekjlhsiIhKVXC7HpEmT0K1bN7UOO/3www+vfcQCEcsNERGJ5u7du2jTpo3aV0N98cUXOHv2LMzNzbWcjPQZyw0REYli7969cHV1xblz50qdtbCwwJo1axAdHQ1bW1sdpCN9xpv4ERGRTuXl5WHy5Mn4/vvv1Zp/5513EB0dDZlMpt1gZDBYboiISGdu3boFf39/JCQkqDXfq1cv/PDDD7C2ttZyMjIkPCxFREQ6sXPnTri5ualVbCwtLREaGorw8HAWGyoz7rkhIiKtys3NRWBgINauXavWfOPGjREdHY1mzZppORkZKpYbIiLSmpSUFPj5+eHixYtqzffr1w+rV6+GlZWVlpORIeNhKSIi0oqIiAi4u7urVWwqV66MzZs3IywsjMWG3hj33BARkUbl5ORg3Lhx2LBhg1rz77//PqKjo9GkSRMtJyNjwT03RESkUXv27FG72AwZMgTnz59nsSGNYrkhIiKN6t27N7788svXzlhZWSE8PByhoaGoXLmyjpKRsWC5ISIijZJIJAgNDUWDBg2Kfd/FxQUJCQno3bu3jpORsWC5ISIijbO1tUVUVBTMzMwKLR8xYgTOnj2LRo0aiZSMjAHLDRERaYWHhwcWL14MALC2tkZUVBTWrl0LS0tLkZORoePVUkREpDVjxoxBWloaBg8ejIYNG4odh4yERBAEQewQupSZmQlbW1tkZGTAxsZG7DhERHolPz+/yKEmIl0oy+c3D0sREVGpBEHAunXr8P777+PJkydixyF6LZYbIiJ6rYyMDPTs2RMjR47EjRs3MHDgQBjZTn/SMyw3RERUooSEBLi7uyM6Olq17Oeff8by5cvFC0VUCpYbIiIqQhAErFy5Ej4+Prh161aR96dMmYLz58+LkIyodCw3RERUyLNnz/D5559j7NixkMvlxc7k5+fD398fz58/1204IjWw3BARkcr58+fh5uaGPXv2lDp79+5dHDx4UAepiMqG5YaIiCAIApYuXYqWLVvi7t27pc7b2dnh0KFDfIQCVUi8iR8RkZF78uQJBgwYgP3796s136ZNG0RERKBOnTpaTkZUPtxzQ0RkxM6cOQNXV1e1io1EIsGMGTMQGxvLYkMVGvfcEBEZIaVSie+++w7Tp0+HQqEodd7e3h7bt2+Hr6+vDtIRvRmWGyIiI/P333+jX79+iImJUWu+ffv2CA8Ph4ODg5aTEWkGD0sRERmREydOQCaTqVVspFIpvv32Wxw5coTFhvQK99wQERkBhUKBkJAQBAcHQ6lUljrv6OiIiIgItGvXTvvhiDSM5YaIyMClp6ejT58+OHr0qFrzHTt2xLZt21CrVi0tJyPSDh6WIiIyYMeOHYOLi4taxcbExATz58/HoUOHWGxIr3HPDRGRgSooKMDIkSORnp5e6mydOnUQGRmJVq1a6SAZkXZxzw0RkYEyNTVFREQEzM3NXzvXtWtXJCcns9iQwWC5ISIyYO7u7li8eHGx75mamuK7777Dvn37YGdnp+NkRNrDckNEZOBGjx6N//znP4WWvfXWWzh58iQmTZoEqZQfBWRY+F80EZGBk0gk2LhxI5ydnQEA3bt3R1JSElq0aCFuMCIt4QnFRERGoFq1aoiKisKZM2cwbtw4SCQSsSMRaQ3LDRGRHsrPz4epqWmZSoqnpyc8PT21mIqoYuBhKSIiPXPv3j20adMGy5YtEzsKUYXEckNEpEd++uknuLq64uzZs5gyZQrOnTsndiSiCoflhohID8jlcowfPx49evTAs2fPALy6SZ+/v7/qayJ6heWGiKiCu337Nlq2bIkVK1YUee/evXsYPHgwBEEQIRlRxcRyQ0RUge3atQuurq64cOFCiTN79uzBqlWrdJiKqGJjuSEiqoByc3MREBCAL7/8EpmZmaXOb9y4EQUFBTpIRlTxsdwQEVUwN27cgI+PD9asWaPWfL9+/XDq1CmYmvLuHkQAyw0RUYWyY8cOuLm5ISkpqdTZypUrY/PmzQgLC4OVlZUO0hHpB9Z8IqIK4OXLlxg3bhxCQ0PVmn///fcRHR2NJk2aaDkZkf5huSEiEtm1a9fg5+eHS5cuqTU/ePBgfP/996hcubKWkxHpJx6WIiIS0datW+Hu7q5WsalSpQq2b9+ODRs2sNgQvYbo5Wb16tVwdnaGpaUlvLy8cP78+dfOP3/+HAEBAXB0dISFhQUaNWqEgwcP6igtEZFmZGdnY+DAgejfvz9ycnJKnf/ggw+QkJCAr776SgfpiPSbqIeloqKiEBgYiHXr1sHLywvLly9Hp06dcP36ddSqVavIvFwux0cffYRatWph165dqFOnDu7du4eqVavqPjwRUTn98ccf8PPzw5UrV9SaHzFiBJYuXYpKlSppORmRYZAIIt7W0svLC82bN1fdfEqpVMLJyQljxozB1KlTi8yvW7cO3333Ha5duwYzMzO1fkZeXh7y8vJUX2dmZsLJyQkZGRmwsbHRzC9CRKQGQRCwadMmjBkzBi9fvix13traGqGhofD399dBOqKKLTMzE7a2tmp9fot2WEoulyMhIQG+vr7/DSOVwtfXF/Hx8cWus2/fPnh7eyMgIAD29vZo2rQp5s+fD4VCUeLPCQkJga2trerl5OSk8d+FiKg0WVlZ6Nu3L4YMGaJWsXFzc0NiYiKLDVE5iFZuHj9+DIVCAXt7+0LL7e3tkZaWVuw6t2/fxq5du6BQKHDw4EHMnDkTS5Yswdy5c0v8OUFBQcjIyFC97t+/r9Hfg4hIHbt27UJ4eLhas2PGjMGZM2fw9ttvazkVkWHSq0vBlUolatWqhfXr18PExATu7u548OABvvvuOwQHBxe7joWFBSwsLHSclIiosAEDBmD//v3YvXt3iTO2trbYtGkTPvvsMx0mIzI8ou25sbOzg4mJCdLT0wstT09Ph4ODQ7HrODo6olGjRjAxMVEte++995CWlga5XK7VvEREb0IikWDjxo1wdnYu9v3mzZsjKSmJxYZIA0QrN+bm5nB3d0dsbKxqmVKpRGxsLLy9vYtdp2XLlrh58yaUSqVqWUpKChwdHWFubq71zEREb6Jq1aqIjIws8gyowMBAnDp1CvXr1xcpGZFhUbvcZGZmqv1SV2BgIEJDQxEWFoarV69i5MiRqns/AK8eBhcUFKSaHzlyJJ4+fYpx48YhJSUFBw4cwPz58xEQEFCGX5mISDxeXl5YuHAhAKBatWrYt28flixZwr+gEWmQ2ufcVK1aFRKJRK3Z11299G/+/v74+++/MWvWLKSlpUEmkyEmJkZ1knFqaiqk0v/2LycnJxw+fBgTJkzABx98gDp16mDcuHGYMmWKur8GEZHoJkyYgCdPnmD48OF46623xI5DZHDUvs/Nr7/+qvrnu3fvYurUqRgwYIDqEFJ8fDzCwsIQEhKC/v37ayetBpTlOnkiInXI5XLueSHSsrJ8fpfrJn4dOnTAkCFD0KtXr0LLIyIisH79esTFxZX1W+oMyw0RaYogCFi+fDnWrl2Lc+fOoVq1amJHIjJYWr+JX3x8PDw8PIos9/DwKPXZUEREhuDp06f49NNPERgYiBs3bmDQoEEQ8YbvRPQv5So3Tk5OCA0NLbJ8w4YNvAMwERm8M2fOQCaT4eeff1Yt27t3L1auXCliKiL6R7lu4rds2TJ8/vnnOHToELy8vAAA58+fx40bN/Djjz9qNCARUUWhVCqxePFiTJs2rdgLJyZNmgQfH59i92wTke6Ua89Nly5dkJKSgm7duuHp06d4+vQpunXrhpSUFHTp0kXTGYmIRPf333/jk08+wZQpU0q8IjQ/Px/+/v7IyMjQcToi+jdRnwouBp5QTERldeLECfTq1QsPHz4sdVYikWDnzp34/PPPdZCMyHjo5KngJ0+eRJ8+feDj44MHDx4AALZt24ZTp06V91sSEVUoSqUS8+bNw4cffqhWsXFwcEBsbCyLDZHIylVufvzxR3Tq1AmVKlVCYmIi8vLyAAAZGRmYP3++RgMSEYkhPT0dnTt3xowZMwo98qUkH330ES5evIgPP/xQB+mI6HXKVW7mzp2LdevWITQ0FGZmZqrlLVu2RGJiosbCERGJ4dixY5DJZPjll19KnZVKpZg3bx5iYmJQq1YtHaQjotKU62qp69evo02bNkWW29ra4vnz52+aiYhIFAqFAnPmzMHs2bPVumdNnTp1sGPHDrRu3VoH6YhIXeUqNw4ODrh58yacnZ0LLT916hQaNGigiVxERDr18OFDfPXVV2rfYb1Lly4ICwuDnZ2ddoMRUZmV67DU0KFDMW7cOJw7dw4SiQQPHz5EeHg4Jk2ahJEjR2o6IxGRVh05cgQymUytYmNqaopFixbh559/ZrEhqqDKtedm6tSpUCqV6NChA3JyctCmTRtYWFhg0qRJGDNmjKYzEhFpRUFBAYKDgxESEqLWYai33noLkZGRqgcGE1HF9Eb3uZHL5bh58yZevHiBJk2awMrKSpPZtIL3uSEiAPjzzz/Rq1cvtW9f0b17d2zevBnVq1fXcjIiKo7W73MzaNAgZGVlwdzcHE2aNIGnpyesrKyQnZ2NQYMGlSs0EZGuHDx4EDKZTK1iY2ZmhmXLlmHv3r0sNkR6olx7bkxMTPDXX38Vuezx8ePHcHBwQEFBgcYCahr33BAZN7lcjvfeew+3b98udbZ+/fqIiopC8+bNdZCMiF5Ha3tuMjMzkZGRAUEQkJWVhczMTNXr2bNnOHjwIO/zQEQVmrm5OXbs2FHoHl3F+fzzz5GYmMhiQ6SHynRCcdWqVSGRSCCRSNCoUaMi70skEnz77bcaC0dEpA2enp5YuHAhAgMDi7xnbm6OpUuXYtSoUZBIJCKkI6I3VaZyc/z4cQiCgPbt2+PHH38sdPzZ3Nwc9erVQ+3atTUekohI08aPH4+4uDjs27dPtaxhw4aIjo6Gm5ubiMmI6E2V65ybe/fu4a233tLLv9XwnBsi+sfTp08hk8lw//59+Pv7Y/369fxzgaiCKsvnd7nuc3Ps2DFYWVnhyy+/LLR8586dyMnJQf/+/cvzbYmIdKp69eqIjIzE5cuXMXToUL38CxsRFVWuS8FDQkKKvTNnrVq1+FRwIhKNXC5X62Z8/+bj44Nhw4ax2BAZkHKVm9TUVNSvX7/I8nr16iE1NfWNQxERldXNmzfRokULrFy5UuwoRCSycpWbWrVq4ffffy+y/OLFi6hRo8YbhyIiKovIyEi4ubkhKSkJkyZNwoULF8SOREQiKle56dWrF8aOHYvjx49DoVBAoVDg2LFjGDduHHr27KnpjERExXr58iWGDx+OXr16ISsrCwCQn58Pf39/ZGRkiJyOiMRSrhOK58yZg7t376JDhw4wNX31LZRKJfr168dzbohIJ65fvw4/P79i9yLfvn0bQ4YMQXR0NM+lITJCb/TgzJSUFFy8eBGVKlVCs2bNUK9ePU1m0wpeCk6k/7Zv344RI0YgOzv7tXNr1qzByJEjdZSKiLSpLJ/fb1Ru9BHLDZH+ysnJwejRo7F582a15j09PXHmzBmYmJhoORkRaZtW7nMTGBiIOXPmoEqVKsXesvzfli5dqu63JSJSyx9//AE/Pz9cuXJFrfnhw4dj2bJlLDZERkjtcpOUlIT8/HzVP5eEx7eJSJMEQcCWLVsQEBCAly9fljpvbW2N0NBQ+Pv76yAdEVVEPCxFRBXWixcvMHLkSGzfvl2teTc3N0RFReHtt9/WcjIi0rWyfH6X61JwIiJt+/333+Hh4aF2sRk9ejTOnDnDYkNE6h+W+uyzz9T+prt37y5XGCIiQRAQGhqKsWPHIi8vr9R5W1tbbNy4EZ9//rkO0hGRPlC73Nja2qr+WRAE7NmzB7a2tvDw8AAAJCQk4Pnz52UqQURE/5aZmYnhw4cjMjJSrfnmzZsjKiqq2MfBEJHxUrvc/PvSyylTpsDPzw/r1q1TXYmgUCgwatQonsdCROWSlJQEPz8/3Lx5U635CRMmYMGCBTA3N9dyMiLSN+U6obhmzZo4deoU3n333ULLr1+/Dh8fHzx58kRjATWNJxQTVSyCIGDNmjUIDAyEXC4vdb5atWrYsmULunfvroN0RFRRaP2E4oKCAly7dq3I8mvXrkGpVJbnWxKREXr+/Dm+/PJLjB49Wq1i4+3tjeTkZBYbInqtcj1bauDAgRg8eDBu3boFT09PAMC5c+ewYMECDBw4UKMBichw7dy5Ez/++KNas5MnT8bcuXNhZmam5VREpO/KdVhKqVRi8eLFWLFiBf766y8AgKOjI8aNG4eJEydW6DuC8rAUUcUhCAL+85//4KeffipxpkaNGti6dSu6dOmiw2REVNHo9NlSmZmZAKA3RYHlhqhiefr0KVxdXZGamlrkvdatWyMiIgJ169YVIRkRVSQ6uYlfQUEBjh49ih07dqgeufDw4UO8ePGivN+SiIxQ9erVERUVBVPT/x4ll0gkmD59Oo4dO8ZiQ0RlVq5yc+/ePTRr1gyffvopAgIC8PfffwMAFi5ciEmTJmk0IBEZvhYtWmD+/PkAgFq1auHw4cOYO3duocJDRKSucv3JMW7cOHh4eODixYuoUaOGavl//vMfDB06VGPhiMh4TJw4EVlZWRg5ciQcHR3FjkNEeqxc5ebkyZM4c+ZMkZtnOTs748GDBxoJRkT6LTc3F5aWlmrPS6VSzJ49W4uJiMhYlOuwlFKphEKhKLL8zz//hLW19RuHIiL9pVQqMX/+fHzwwQd4/vy52HGIyAiVq9x07NgRy5cvV30tkUjw4sULBAcH83JNIiP26NEjfPzxx5g+fTpu3LiBoUOH4g0vyCQiKrNyXQp+//59dO7cGYIg4MaNG/Dw8MCNGzdgZ2eHEydOoFatWtrIqhG8FJxIO44fP47evXsjLS2t0PLVq1dj1KhRIqUiIkOhk/vcFBQUICoqChcvXsSLFy/g5uaGr776CpUqVSpXaF1huSHSLIVCgblz52L27NnFPn7F3NwcZ8+ehaurqwjpiMhQaLXc5Ofno3Hjxti/fz/ee++9NwoqBpYbIs3566+/0KdPHxw7duy1c2+//TYSEhL4/xwRlZtWb+JnZmaG3NzccocjIsPwyy+/QCaTlVpsAODOnTs4ceKEDlIREZXzhOKAgAAsXLgQBQUFms5DRBVcQUEBZsyYgU6dOuHRo0elzjs5OeHkyZP45JNPdJCOiKic97n57bffEBsbiyNHjqBZs2aoUqVKofd3796tkXBEVLH8+eef6N27N06ePKnWfPfu3bF582ZUr15dy8mIiP6rXOWmatWq+PzzzzWdhYgqsEOHDqFv37548uRJqbNmZmZYuHAhxo8fr3r2HBGRrpSp3CiVSnz33XdISUmBXC5H+/bt8c0331T4K6SIqPzy8/MxY8YMLFq0SK15Z2dnREVFwdPTU8vJiIiKV6ZzbubNm4dp06bBysoKderUwffff4+AgABtZSMikaWmpqJt27ZqF5vPPvsMSUlJLDZEJKoylZutW7dizZo1OHz4MPbu3Yuff/4Z4eHhxd7bgoj02759+yCTyRAfH1/qrLm5OVatWoVdu3ahatWq2g9HRPQaZSo3qamphR6v4OvrC4lEgocPH75RiNWrV8PZ2RmWlpbw8vLC+fPn1VovMjISEokEPXr0eKOfT0T/JZfLERgYiE8//RTPnj0rdb5hw4aIj49HQEAAz68hogqhTOWmoKCgyFN+zczMkJ+fX+4AUVFRCAwMRHBwMBITE+Hi4qLWJaZ3797FpEmT0Lp163L/bCIq7M6dO2jVqhWWLVum1ry/vz8SExPh5uam5WREROor0x2KpVIpPv74Y1hYWKiW/fzzz2jfvn2hy8HLcim4l5cXmjdvjlWrVgF4ddKyk5MTxowZg6lTpxa7jkKhQJs2bTBo0CCcPHkSz58/x969e9X6ebxDMVHxdu/ejUGDBiEjI6PUWQsLC3z//fcYOnQo99YQkU6U5fO7TFdL9e/fv8iyPn36lC3dv8jlciQkJCAoKEi1TCqVwtfX97XH+WfPno1atWph8ODBpd5vIy8vD3l5eaqvMzMzy52XyFC9fPkSgYGBahWbRo0aYefOnfjggw90kIyIqOzKVG42b96s0R/++PFjKBQK2NvbF1pub2+Pa9euFbvOqVOnsHHjRiQnJ6v1M0JCQvDtt9++aVQig1apUiVERkaidevWr73zeJ8+fbB27VpYWVnpMB0RUdmU6/ELYsnKykLfvn0RGhoKOzs7tdYJCgpCRkaG6nX//n0tpyTSTy1atEBISEix71WqVAkbN27E1q1bWWyIqMIr1x2KNcXOzg4mJiZIT08vtDw9PR0ODg5F5m/duoW7d++iW7duqmX/XIZuamqK69evo2HDhoXWsbCwKHSOEBGVLDAwEHFxcThw4IBqWZMmTRAdHY33339fxGREROoTdc+Nubk53N3dERsbq1qmVCoRGxsLb2/vIvONGzfGpUuXkJycrHp1794dH374IZKTk+Hk5KTL+EQGRyqVIiwsDHXr1gUADBw4EOfPn2exISK9IuqeG+DV3xT79+8PDw8PeHp6Yvny5cjOzsbAgQMBAP369UOdOnUQEhICS0tLNG3atND6/9ww7H+XE1H51KhRA5GRkbh9+zb69u0rdhwiojITvdz4+/vj77//xqxZs5CWlgaZTIaYmBjVScapqamQSvXq1CCiCiU3NxcWFhZlumS7ZcuWaNmypRZTERFpT5nuc2MIeJ8bMiZXrlzBl19+iZEjR2L06NFixyEiKreyfH5zlwiRARIEAZs3b4aHhweuXLmCiRMnIjExUexYREQ6wXJDZGBevHiB/v37Y9CgQXj58iWAVzfM9PPz400sicgosNwQGZDff/8dzZs3x7Zt24q8d+vWLQwbNgxGdiSaiIwQyw2RARAEAevXr4eXl1eJd/cGXj2oNjQ0VIfJiIh0j+WGSM9lZmaid+/eGD58OHJzc0ud3759u+rml0REhojlhkiPJSUlwd3dHZGRkWrNjx8/HkePHuXtFYjIoPFPOCI9JAgCVq9ejRYtWuDmzZulzletWhV79+7FsmXLYG5uroOERETiEf0mfkRUNs+fP8fQoUOxa9cuteZbtGiByMhI1KtXT8vJiIgqBu65IdIjv/32G9zc3NQuNl9//TVOnDjBYkNERoXlhkgPCIKA5cuXo2XLlrhz506p8zVq1MD+/fuxaNEimJmZ6SAhEVHFwcNSRBXc06dPMWjQIPz0009qzbdq1Qo7duxQPdmbiMjYcM8NUQV29uxZuLq6qlVsJBIJpk2bhuPHj7PYEJFR454bogpIqVRiyZIlmDZtGgoKCkqdr1mzJrZv346OHTvqIB0RUcXGckNUwTx+/BgDBgzAgQMH1Jpv164dwsPDUbt2bS0nIyLSDzwsRVTBREVFqVVsJBIJgoODcfToURYbIqJ/YbkhqmBGjhyJrl27vnbGwcEBR48exTfffAMTExMdJSMi0g8sN0QVjFQqRVhYWIknBfv6+iI5ORnt27fXcTIiIv3AckNUAdWoUQM7duwotFdGKpVi7ty5OHz4MOzt7UVMR0RUsbHcEFVQrVq1wpw5cwAAtWvXxvHjxzF9+nQ+9JKIqBS8WoqoApsyZQrkcjlGjRqFmjVrih2HiEgvSARBEMQOoUuZmZmwtbVFRkYGbGxsxI5DRiYnJweVK1cWOwYRkd4py+c3928T6UBBQQFmzJgBmUyGzMxMseMQERk0lhsiLXvw4AHat2+PefPm4caNGxg2bBiMbIcpEZFOsdwQadGhQ4cgk8lw8uRJ1bKoqCiEhoaKmIqIyLCx3BBpQX5+PqZMmYIuXbrg8ePHRd4fN24cfv/9dxGSEREZPpYbIg1LTU1Fu3btsGjRohJncnNz4efnhxcvXugwGRGRcWC5IdKgn3/+GTKZDGfOnCl19s6dO4iPj9dBKiIi48JyQ6QBcrkcEydORPfu3fHs2bNS5xs2bIgzZ87go48+0kE6IiLjwpv4Eb2hO3fuoGfPnjh//rxa835+fggNDeV9loiItIR7bojewO7du+Hq6qpWsbGwsMC6desQGRnJYkNEpEXcc0NUDnl5eZg0aRJWrVql1nyjRo0QHR0NFxcXLScjIiKWG6IyunnzJvz9/ZGYmKjW/FdffYW1a9fC2tpay8mIiAjgYSmiMomOjoabm5taxaZSpUrYuHEjtm3bxmJDRKRD3HNDpIaXL18iMDAQ69atU2v+vffeQ3R0NJo2barlZERE9L9YbohKcf36dfj5+al9R+GBAwdi5cqVqFKlipaTERFRcXhYiug1wsPD4e7urlaxqVy5MrZu3YpNmzax2BARiYh7bohKkJ2djalTpyI7O7vU2WbNmiE6OhqNGzfWQTIiInod7rkhKkGVKlUQGRkJExOT184NHToU586dY7EhIqogWG6IXqNly5aYO3duse9ZWVkhIiIC69evR6VKlXScjIiISsJyQ1SKyZMno3PnzoWWyWQyJCYmolevXiKlIiKikrDcEJVCKpVi69atqF27NgBg1KhRiI+PxzvvvCNyMiIiKg5PKCZSQ82aNbFjxw48evQIX3zxhdhxiIjoNVhuyCjl5OSgUqVKkEgkaq/Tpk0bLSYiIiJN4WEpMjpJSUlwcXHBDz/8IHYUIiLSApYbMhqCIGDNmjVo0aIFbt68ifHjx+PixYtixyIiIg1juSGjkJGRAT8/PwQEBEAulwMA8vLy4Ofnh6ysLJHTERGRJrHckMG7cOECXF1dsWvXriLvpaSkYOTIkRAEQYRkRESkDSw3ZLAEQcCKFSvg4+ODO3fulDgXHh6OzZs36zAZERFpE8sNGaRnz57hs88+w/jx45Gfn1/qfGRkJPfeEBEZCJYbMjhnz56Fq6sr9u7dq9Z8UFAQDh48WKbLwomIqOLifW7IYCiVSixduhRBQUEoKCgodb5mzZrYtm0bOnXqpIN0RESkKyw3ZBCePHmC/v3748CBA2rNt2vXDuHh4apHKhARkeHgYSnSe6dOnYJMJlOr2EgkEsyaNQtHjx5lsSEiMlDcc0N6S6lUYuHChZg5cyYUCkWp8/b29ggPD0eHDh10kI6IiMTCckN66dGjR+jbty+OHDmi1nyHDh2wfft2ODg4aDkZERGJjYelSO/ExcVBJpOpVWykUinmzJmDw4cPs9gQERmJClFuVq9eDWdnZ1haWsLLywvnz58vcTY0NBStW7dGtWrVUK1aNfj6+r52ngyHQqHA7Nmz0aFDB/z111+lzteuXRvHjh3DjBkzYGJiooOERERUEYhebqKiohAYGIjg4GAkJibCxcUFnTp1wqNHj4qdj4uLQ69evXD8+HHEx8fDyckJHTt2xIMHD3ScnHQpLS0NHTt2RHBwMJRKZanznTt3RnJyMtq2bauDdEREVJFIBJFvy+rl5YXmzZtj1apVAF6dJOrk5IQxY8Zg6tSppa6vUChQrVo1rFq1Cv369St1PjMzE7a2tsjIyICNjc0b5yfdWL58OSZMmFDqnImJCebNm4evv/4aUqno3Z2IiDSkLJ/fov7pL5fLkZCQAF9fX9UyqVQKX19fxMfHq/U9cnJykJ+fj+rVqxf7fl5eHjIzMwu9SP+MHTsWnTt3fu1M3bp18euvv2LKlCksNkRERkzUT4DHjx9DoVDA3t6+0HJ7e3ukpaWp9T2mTJmC2rVrFypI/xYSEgJbW1vVy8nJ6Y1zk+5JpVJs3bq1xHvTfPLJJ0hOTkbLli11nIyIiCoavf7r7YIFCxAZGYk9e/bA0tKy2JmgoCBkZGSoXvfv39dxStKUmjVrYseOHYX2ypiammLJkiXYt28fatSoIWI6IiKqKEQtN3Z2djAxMUF6enqh5enp6aVetrt48WIsWLAAR44cwQcffFDinIWFBWxsbAq9SH+1adMG3377LQCgXr16OHXqFAIDA/nQSyIiUhG13Jibm8Pd3R2xsbGqZUqlErGxsfD29i5xvUWLFmHOnDmIiYmBh4eHLqJSBRIUFIQ5c+YgKSkJXl5eYschIqIKRvQ7FAcGBqJ///7w8PCAp6cnli9fjuzsbAwcOBAA0K9fP9SpUwchISEAgIULF2LWrFmIiIiAs7Oz6twcKysrWFlZifZ7UPllZ2ejSpUqas+bmJhgxowZWkxERET6TPRzbvz9/bF48WLMmjULMpkMycnJiImJUZ1knJqaWuiGbWvXroVcLscXX3wBR0dH1Wvx4sVi/QpUTnK5HBMnToSbmxuysrLEjkNERAZC9Pvc6Brvc1Mx3L17Fz179sS5c+cAAL1798b27dt57gwRERVLb+5zQ8Zpz549cHV1VRUbAIiIiMCmTZtETEVERIaC5YZ0Ji8vD2PHjsVnn32G58+fF3l/zJgxuHz5su6DERGRQWG5IZ24desWWrZsiZUrV5Y48/LlS/j5+SE7O1uHyYiIyNCw3JDW7dy5E25ubkhISCh19s6dO/jtt990kIqIiAwVyw1pTW5uLkaNGgU/Pz+1nunVuHFj/Pbbb2jXrp32wxERkcES/T43ZJhSUlLg5+eHixcvqjXfv39/rF69ukz3uyEiIioO99yQxkVERMDd3V2tYlO5cmVs2bIFW7ZsYbEhIiKN4J4b0picnByMGzcOGzZsUGu+adOmiIqKQpMmTbScjIiIjAnLDWnE1atX4efnp/al3EOGDMGKFStQuXJlLScjIiJjw8NS9MbCwsLg4eGhVrGxsrJCeHg4QkNDWWyIiEgruOeGyi07OxsBAQEICwtTa97FxQXR0dFo1KiRlpMREZEx454bKpfLly/Dw8ND7WIzatQonD17lsWGiIi0juWGykQQBGzYsAHNmzfHtWvXSp23sbFBdHQ0Vq9eDUtLSx0kJCIiY8fDUlQmWVlZCA4ORm5ubqmz7u7uiIqKQsOGDXWQjIiI6BXuuaEysbGxwY4dOyCVvv4/nbFjx+L06dMsNkREpHMsN1Rmbdq0wbffflvse1WrVsWePXuwYsUKWFhY6DgZERERyw2VU1BQEHx9fQst8/LyQlJSEnr06CFOKCIiIrDcUDmZmJhg+/btcHBwAABMnDgRJ06cgLOzs7jBiIjI6PGEYio3e3t77NixAy9evMAnn3widhwiIiIALDf0Ly9evECVKlUgkUjUXqddu3baC0RERFQOPCxFAIBz586hadOm2Lhxo9hRiIiI3gjLjZFTKpVYsmQJWrVqhXv37mHMmDG4dOmS2LGIiIjKjeXGiD158gTdu3fHpEmTUFBQAADIzc2Fn58fXrx4IXI6IiKi8mG5MVKnT5+GTCbDgQMHirx37do1jB49WoRUREREb47lxsgolUosWLAAbdu2xZ9//lniXFhYmNoPxSQiIqpIWG6MyKNHj9ClSxcEBQVBoVCUOv/jjz9CEAQdJCMiItIclhsj8euvv0Imk+Hw4cOlzkqlUnz77bfYs2dPmS4LJyIiqgh4nxsDp1AoMH/+fHzzzTdQKpWlzjs6OiIiIoL3ryEiIr3FcmPA0tLS0KdPH8TGxqo137FjR2zbtg21atXScjIiIiLt4WEpAxUbGwuZTKZWsTExMUFISAgOHTrEYkNERHqPe24MTEFBAWbPno25c+eqdTJw3bp1sWPHDrRq1UoH6YiIiLSP5caAPHz4EL169cKJEyfUmu/atSu2bNkCOzs7LScjIiLSHR6WMhAxMTFwcXFRq9iYmppi8eLF2LdvH4sNEREZHO650XMFBQWYOXMmFixYoNZ8vXr1EBkZiRYtWmg5GRERkThYbvTY/fv30atXL5w+fVqt+R49emDTpk2oVq2alpMRERGJh4el9FhUVJRaxcbMzAwrVqzA7t27WWyIiMjgsdzoscDAQHz00UevnWnQoAHOnDmDsWPH8m7DRERkFFhu9JhUKsW2bdvg4OBQ7PtffPEFEhMT4eHhoeNkRERE4mG50XP29vaIiIiAVPrff5UWFhZYs2YNoqOjYWtrK2I6IiIi3WO5MQAffvghZs2aBQB45513cPbsWYwcOZKHoYiIyCjxaikDMWPGDJibm2P06NGwtrYWOw4REZFoJII69+g3IJmZmbC1tUVGRgZsbGzEjlOirKwslhQiIqL/V5bPbx6WqmByc3MxatQoeHp64sWLF2LHISIi0jssNxXIjRs34O3tjbVr1+LatWsICAgQOxIREZHeYbmpIHbs2AE3NzckJyerlm3duhVhYWHihSIiItJDLDciy8nJwdChQ9G7d+9iD0ONGjUKV65cESEZERGRfmK5EdHVq1fh5eWFDRs2lDiTk5MDPz8/5OTk6DAZERGR/mK5EUlYWBg8PDxw+fLlUmfv3r1b6HAVERERlYzlRseys7MxYMAADBgwQK29MS4uLkhMTISPj48O0hEREek/lhsdunz5Mpo3b672ScIjRoxAfHw8GjVqpOVkREREhoPlRgcEQcDGjRvRvHlzXL16tdR5a2trREVFYe3atahUqZIOEhIRERkOPn5By7KysjBy5EiEh4erNe/m5obo6Gg0bNhQy8mIiIgME/fcaNHFixfh4eGhdrEZM2YMzpw5w2JDRET0BlhutEAQBKxbtw5eXl5ISUkpdd7W1hY//vgjvv/+e1hYWOggIRERkeHiYSkNy8jIwLBhwxAdHa3WvKenJyIjI1G/fn0tJyMiIjIOLDcaolAK2PrzMUwbMxhp9++ptU5gYCBCQkJgbm6u5XRERETaJy9QYlv8Xdx7moN61Sujr7czzE11f5CoQhyWWr16NZydnWFpaQkvLy+cP3/+tfM7d+5E48aNYWlpiWbNmuHgwYM6Slq8Q5ce4u1Px2DQ553VKjbVqlXDvn37sGTJEhYbIiIyCCEHr6DxzEOYc+Aqtsbfw5wDV9F45iGEHNT9I4RELzdRUVEIDAxEcHAwEhMT4eLigk6dOuHRo0fFzp85cwa9evXC4MGDkZSUhB49eqBHjx5q3elXG2Iu/4XhG0/iftwOQFFQ6ryPjw+Sk5PRrVs3HaQjIiLSvpCDV/DDiTtQCoWXKwXghxN3dF5wJIIgCKWPaY+XlxeaN2+OVatWAQCUSiWcnJwwZswYTJ06tci8v78/srOzsX//ftWyFi1aQCaTYd26daX+vMzMTNja2iIjIwM2NjZvlF2hFNBq4TH8lZGL3NTfkR45AxCUJc5PmTIFc+bMgZmZ2Rv9XCIioopCXqBE45mHihSbf5NKgGtzPn6jQ1Rl+fwWdc+NXC5HQkICfH19VcukUil8fX0RHx9f7Drx8fGF5gGgU6dOJc7n5eUhMzOz0EtTzt95ir8ycgEAlm99ANuWvYqdq1qtBg4dOoQFCxaw2BARkUHZFn/3tcUGeLUHZ1v8XZ3kAUQuN48fP4ZCoYC9vX2h5fb29khLSyt2nbS0tDLNh4SEwNbWVvVycnLSTHgAj7JyC31t6+0Hy3ofFFpm4dQUSyJj0LlzZ439XCIioori3tPSn5NYljlNEP2cG20LCgpCRkaG6nX//n2Nfe9a1paFvpZITWD3ydeQVq4KQAJbb3/Y95yH9xryMm8iIjJM9apX1uicJoh6KbidnR1MTEyQnp5eaHl6ejocHByKXcfBwaFM8xYWFlq7MZ5n/epwtLVEWkYu/tkjZ2JVDXbdvwYEAZWdZXCwtYRn/epa+flERERi6+vtjHkHr5Z6zk1fb2edZRJ1z425uTnc3d0RGxurWqZUKhEbGwtvb+9i1/H29i40DwC//PJLifPaZCKVILhbEwCA5F/LK9VzQWVnGQAguFsTmEglRVcmIiIyAOamUgxt/fojFENb19fp/W5EPywVGBiI0NBQhIWF4erVqxg5ciSys7MxcOBAAEC/fv0QFBSkmh83bhxiYmKwZMkSXLt2Dd988w0uXLiA0aNHi5K/c1NHrO3jBgfbwoeoHGwtsbaPGzo3dRQlFxERka4EdWmC4W3q43//Li+VAMPb1EdQlyY6zSP6HYr9/f3x999/Y9asWUhLS4NMJkNMTIzqpOHU1FRIpf/tYD4+PoiIiMCMGTMwbdo0vPPOO9i7dy+aNm0q1q+Azk0d8VETB5y/8xSPsnJRy/rVoSjusSEiImMR1KUJJnZsXCHuUCz6fW50TZP3uSEiIiLd0Jv73BARERFpGssNERERGRSWGyIiIjIoLDdERERkUFhuiIiIyKCw3BAREZFBYbkhIiIig8JyQ0RERAaF5YaIiIgMiuiPX9C1f27InJmZKXISIiIiUtc/n9vqPFjB6MpNVlYWAMDJyUnkJERERFRWWVlZsLW1fe2M0T1bSqlU4uHDh7C2toZEotkHW2ZmZsLJyQn379/nc6u0iNtZN7iddYPbWXe4rXVDW9tZEARkZWWhdu3ahR6oXRyj23MjlUpRt25drf4MGxsb/o+jA9zOusHtrBvczrrDba0b2tjOpe2x+QdPKCYiIiKDwnJDREREBoXlRoMsLCwQHBwMCwsLsaMYNG5n3eB21g1uZ93httaNirCdje6EYiIiIjJs3HNDREREBoXlhoiIiAwKyw0REREZFJYbIiIiMigsN2W0evVqODs7w9LSEl5eXjh//vxr53fu3InGjRvD0tISzZo1w8GDB3WUVL+VZTuHhoaidevWqFatGqpVqwZfX99S/73QK2X97/kfkZGRkEgk6NGjh3YDGoiybufnz58jICAAjo6OsLCwQKNGjfhnhxrKup2XL1+Od999F5UqVYKTkxMmTJiA3NxcHaXVTydOnEC3bt1Qu3ZtSCQS7N27t9R14uLi4ObmBgsLC7z99tvYsmWL1nNCILVFRkYK5ubmwqZNm4Q//vhDGDp0qFC1alUhPT292PnTp08LJiYmwqJFi4QrV64IM2bMEMzMzIRLly7pOLl+Ket27t27t7B69WohKSlJuHr1qjBgwADB1tZW+PPPP3WcXL+UdTv/486dO0KdOnWE1q1bC59++qluwuqxsm7nvLw8wcPDQ+jSpYtw6tQp4c6dO0JcXJyQnJys4+T6pazbOTw8XLCwsBDCw8OFO3fuCIcPHxYcHR2FCRMm6Di5fjl48KAwffp0Yffu3QIAYc+ePa+dv337tlC5cmUhMDBQuHLlirBy5UrBxMREiImJ0WpOlpsy8PT0FAICAlRfKxQKoXbt2kJISEix835+fkLXrl0LLfPy8hKGDx+u1Zz6rqzb+X8VFBQI1tbWQlhYmLYiGoTybOeCggLBx8dH2LBhg9C/f3+WGzWUdTuvXbtWaNCggSCXy3UV0SCUdTsHBAQI7du3L7QsMDBQaNmypVZzGhJ1ys3kyZOF999/v9Ayf39/oVOnTlpMJgg8LKUmuVyOhIQE+Pr6qpZJpVL4+voiPj6+2HXi4+MLzQNAp06dSpyn8m3n/5WTk4P8/HxUr15dWzH1Xnm38+zZs1GrVi0MHjxYFzH1Xnm28759++Dt7Y2AgADY29ujadOmmD9/PhQKha5i653ybGcfHx8kJCSoDl3dvn0bBw8eRJcuXXSS2ViI9TlodA/OLK/Hjx9DoVDA3t6+0HJ7e3tcu3at2HXS0tKKnU9LS9NaTn1Xnu38v6ZMmYLatWsX+R+K/qs82/nUqVPYuHEjkpOTdZDQMJRnO9++fRvHjh3DV199hYMHD+LmzZsYNWoU8vPzERwcrIvYeqc827l37954/PgxWrVqBUEQUFBQgBEjRmDatGm6iGw0SvoczMzMxMuXL1GpUiWt/FzuuSGDsmDBAkRGRmLPnj2wtLQUO47ByMrKQt++fREaGgo7Ozux4xg0pVKJWrVqYf369XB3d4e/vz+mT5+OdevWiR3NoMTFxWH+/PlYs2YNEhMTsXv3bhw4cABz5swROxppAPfcqMnOzg4mJiZIT08vtDw9PR0ODg7FruPg4FCmeSrfdv7H4sWLsWDBAhw9ehQffPCBNmPqvbJu51u3buHu3bvo1q2baplSqQQAmJqa4vr162jYsKF2Q+uh8vz37OjoCDMzM5iYmKiWvffee0hLS4NcLoe5ublWM+uj8mznmTNnom/fvhgyZAgAoFmzZsjOzsawYcMwffp0SKX8u78mlPQ5aGNjo7W9NgD33KjN3Nwc7u7uiI2NVS1TKpWIjY2Ft7d3set4e3sXmgeAX375pcR5Kt92BoBFixZhzpw5iImJgYeHhy6i6rWybufGjRvj0qVLSE5OVr26d++ODz/8EMnJyXByctJlfL1Rnv+eW7ZsiZs3b6rKIwCkpKTA0dGRxaYE5dnOOTk5RQrMP4VS4CMXNUa0z0Gtnq5sYCIjIwULCwthy5YtwpUrV4Rhw4YJVatWFdLS0gRBEIS+ffsKU6dOVc2fPn1aMDU1FRYvXixcvXpVCA4O5qXgaijrdl6wYIFgbm4u7Nq1S/jrr79Ur6ysLLF+Bb1Q1u38v3i1lHrKup1TU1MFa2trYfTo0cL169eF/fv3C7Vq1RLmzp0r1q+gF8q6nYODgwVra2thx44dwu3bt4UjR44IDRs2FPz8/MT6FfRCVlaWkJSUJCQlJQkAhKVLlwpJSUnCvXv3BEEQhKlTpwp9+/ZVzf9zKfjXX38tXL16VVi9ejUvBa+IVq5cKbz11luCubm54OnpKZw9e1b1Xtu2bYX+/fsXmo+OjhYaNWokmJubC++//75w4MABHSfWT2XZzvXq1RMAFHkFBwfrPrieKet/z//GcqO+sm7nM2fOCF5eXoKFhYXQoEEDYd68eUJBQYGOU+ufsmzn/Px84ZtvvhEaNmwoWFpaCk5OTsKoUaOEZ8+e6T64Hjl+/Hixf97+s2379+8vtG3btsg6MplMMDc3Fxo0aCBs3rxZ6zklgsD9b0RERGQ4eM4NERERGRSWGyIiIjIoLDdERERkUFhuiIiIyKCw3BAREZFBYbkhIiIig8JyQ0RERAaF5YaIiIgMCssNEZGGtGvXDuPHjxc7BpHRY7khIo0aMGAAJBIJRowYUeS9gIAASCQSDBgwQPfBiMhosNwQkcY5OTkhMjISL1++VC3Lzc1FREQE3nrrLRGTlU4ul4sdgYjeEMsNEWmcm5sbnJycsHv3btWy3bt346233oKrq6tqmVKpREhICOrXr49KlSrBxcUFu3btUr2vUCgwePBg1fvvvvsuVqxYUehnxcXFwdPTE1WqVEHVqlXRsmVL3Lt3D8CrvUg9evQoND9+/Hi0a9dO9XW7du0wevRojB8/HnZ2dujUqRMA4PLly/j4449hZWUFe3t79O3bF48fP1atl52djX79+sHKygqOjo5YsmTJG283ItIMlhsi0opBgwZh8+bNqq83bdqEgQMHFpoJCQnB1q1bsW7dOvzxxx+YMGEC+vTpg19//RXAq/JTt25d7Ny5E1euXMGsWbMwbdo0REdHAwAKCgrQo0cPtG3bFr///jvi4+MxbNgwSCSSMmUNCwuDubk5Tp8+jXXr1uH58+do3749XF1dceHCBcTExCA9PR1+fn6qdb7++mv8+uuv+Omnn3DkyBHExcUhMTGxvJuLiDTIVOwARGSY+vTpg6CgINVelNOnTyMyMhJxcXEAgLy8PMyfPx9Hjx6Ft7c3AKBBgwY4deoUfvjhB7Rt2xZmZmb49ttvVd+zfv36iI+PR3R0NPz8/JCZmYmMjAx88sknaNiwIQDgvffeK3PWd955B4sWLVJ9PXfuXLi6umL+/PmqZZs2bYKTkxNSUlJQu3ZtbNy4Edu3b0eHDh0AvCpIdevWLfPPJiLNY7khIq2oWbMmunbtii1btkAQBHTt2hV2dnaq92/evImcnBx89NFHhdaTy+WFDl2tXr0amzZtQmpqKl6+fAm5XA6ZTAYAqF69OgYMGIBOnTrho48+gq+vL/z8/ODo6FimrO7u7oW+vnjxIo4fPw4rK6sis7du3VLl8PLyUi2vXr063n333TL9XCLSDpYbItKaQYMGYfTo0QBelZR/e/HiBQDgwIEDqFOnTqH3LCwsAACRkZGYNGkSlixZAm9vb1hbW+O7777DuXPnVLObN2/G2LFjERMTg6ioKMyYMQO//PILWrRoAalUCkEQCn3v/Pz8IjmrVKlSJFu3bt2wcOHCIrOOjo64efOmupuAiETAckNEWtO5c2fI5XJIJBLVibr/aNKkCSwsLJCamoq2bdsWu/7p06fh4+ODUaNGqZbdunWryJyrqytcXV0RFBQEb29vREREoEWLFqhZsyYuX75caDY5ORlmZmavze3m5oYff/wRzs7OMDUt+sdkw4YNYWZmhnPnzqmu/nr27BlSUlJK/F2ISHd4QjERaY2JiQmuXr2KK1euwMTEpNB71tbWmDRpEiZMmICwsDDcunULiYmJWLlyJcLCwgC8OhfmwoULOHz4MFJSUjBz5kz89ttvqu9x584dBAUFIT4+Hvfu3cORI0dw48YN1Xk37du3x4ULF7B161bcuHEDwcHBRcpOcQICAvD06VP06tULv/32G27duoXDhw9j4MCBUCgUsLKywuDBg/H111/j2LFjuHz5MgYMGACplH+kElUE3HNDRFplY2NT4ntz5sxBzZo1ERISgtu3b6Nq1apwc3PDtGnTAADDhw9HUlIS/P39IZFI0KtXL4waNQqHDh0CAFSuXBnXrl1DWFgYnjx5AkdHRwQEBGD48OEAgE6dOmHmzJmYPHkycnNzMWjQIPTr1w+XLl16bebatWvj9OnTmDJlCjp27Ii8vDzUq1cPnTt3VhWY7777TnX4ytraGhMnTkRGRoYmNhkRvSGJ8L8HpImIiIj0GPehEhERkUFhuSEiIiKDwnJDREREBoXlhoiIiAwKyw0REREZFJYbIiIiMigsN0RERGRQWG6IiIjIoLDcEBERkUFhuSEiIiKDwnJDREREBuX/ACkAZQMtevdIAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "# 西瓜数据集\n",
    "dataSet = [['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '好瓜'], \n",
    "          ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', '好瓜'], \n",
    "          ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '好瓜'], \n",
    "          ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', '好瓜'], \n",
    "          ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '好瓜'], \n",
    "          ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', '好瓜'], \n",
    "          ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', '好瓜'], \n",
    "          ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', '好瓜'], \n",
    "          ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', '坏瓜'], \n",
    "          ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', '坏瓜'], \n",
    "          ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', '坏瓜'], \n",
    "          ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', '坏瓜'], \n",
    "          ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', '坏瓜'], \n",
    "          ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', '坏瓜'], \n",
    "          ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', '坏瓜'], \n",
    "          ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', '坏瓜'], \n",
    "          ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', '坏瓜']]\n",
    "\n",
    "# 特征名称\n",
    "feature_names = ['色泽', '根蒂', '敲声', '纹理', '脐部', '触感', '好坏']\n",
    "\n",
    "def prepareDataSet():\n",
    "    \"\"\"准备数据集，将文本特征转换为数值特征\"\"\"\n",
    "    # 创建DataFrame\n",
    "    df = pd.DataFrame(dataSet, columns=feature_names)\n",
    "    \n",
    "    # 分离特征和标签\n",
    "    X = df.iloc[:, :-1]  # 所有行，除最后一列外的所有列作为特征\n",
    "    y = df.iloc[:, -1]   # 所有行，最后一列作为标签\n",
    "    \n",
    "    # 对标签进行编码：好瓜->1，坏瓜->0\n",
    "    label_encoder = LabelEncoder()\n",
    "    y_encoded = label_encoder.fit_transform(y)\n",
    "    \n",
    "    # 对特征进行编码\n",
    "    X_encoded = X.copy()\n",
    "    for column in X.columns:\n",
    "        X_encoded[column] = label_encoder.fit_transform(X[column])\n",
    "    \n",
    "    return X_encoded, y_encoded\n",
    "\n",
    "def getTrainSetAndTestSet(X, y):\n",
    "    \"\"\"划分训练集和测试集\"\"\"\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=1)\n",
    "    print(\"训练集特征维度:\", X_train.shape)\n",
    "    print(\"训练集标签维度:\", y_train.shape)\n",
    "    print(\"测试集特征维度:\", X_test.shape)\n",
    "    print(\"测试集标签维度:\", y_test.shape)\n",
    "    return X_train, X_test, y_train, y_test\n",
    "\n",
    "def TrainDecisionTreeRegressor(X_train, y_train):\n",
    "    \"\"\"训练决策树回归模型\"\"\"\n",
    "    # 创建决策树回归模型\n",
    "    tree_reg = DecisionTreeRegressor(criterion='squared_error', max_depth=3, random_state=1)\n",
    "    # 训练模型\n",
    "    tree_reg.fit(X_train, y_train)\n",
    "    print(\"决策树特征重要性:\", tree_reg.feature_importances_)\n",
    "    return tree_reg\n",
    "\n",
    "def EvaluationModel(tree_reg, X_test, y_test):\n",
    "    \"\"\"评估模型性能\"\"\"\n",
    "    y_pred = tree_reg.predict(X_test)\n",
    "    mse = np.mean((y_pred - y_test) ** 2)\n",
    "    print(\"均方误差MSE:\", mse)\n",
    "    rmse = np.sqrt(mse)\n",
    "    print(\"均方根误差RMSE:\", rmse)\n",
    "    \n",
    "    # 计算准确率（将预测值四舍五入后与实际值比较）\n",
    "    y_pred_rounded = np.round(y_pred)\n",
    "    accuracy = np.mean(y_pred_rounded == y_test)\n",
    "    print(\"准确率:\", accuracy)\n",
    "    \n",
    "    return y_pred\n",
    "\n",
    "def Visualization(y_test, y_pred):\n",
    "    \"\"\"可视化结果\"\"\"\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.scatter(y_test, y_pred)\n",
    "    ax.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], 'k--', lw=5)\n",
    "    ax.set_xlabel(\"Measured\")\n",
    "    ax.set_ylabel(\"Predicted\")\n",
    "    \n",
    "    plt.show()\n",
    "    plt.close(fig)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # 准备数据集\n",
    "    X, y = prepareDataSet()\n",
    "    \n",
    "    # 划分训练集和测试集\n",
    "    X_train, X_test, y_train, y_test = getTrainSetAndTestSet(X, y)\n",
    "    \n",
    "    # 训练决策树回归模型\n",
    "    tree_reg_model = TrainDecisionTreeRegressor(X_train, y_train)\n",
    "    \n",
    "    # 评估模型性能\n",
    "    y_pred = EvaluationModel(tree_reg_model, X_test, y_test)\n",
    "    \n",
    "    # 可视化结果\n",
    "    Visualization(y_test, y_pred)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env0",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
